home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / INTERNET / SITES / LITTLE / P3SRC.ZIP / ATARI / TEXTURE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-25  |  32.4 KB  |  1,570 lines
  1. /****************************************************************************
  2. *                texture.c
  3. *
  4. *  This module implements texturing functions such as noise, turbulence and
  5. *  texture transformation functions. The actual texture routines are in the
  6. *  files pigment.c & normal.c.
  7. *  The noise function used here is the one described by Ken Perlin in
  8. *  "Hypertexture", SIGGRAPH '89 Conference Proceedings page 253.
  9. *
  10. *  from Persistence of Vision(tm) Ray Tracer
  11. *  Copyright 1996 Persistence of Vision Team
  12. *---------------------------------------------------------------------------
  13. *  NOTICE: This source code file is provided so that users may experiment
  14. *  with enhancements to POV-Ray and to port the software to platforms other 
  15. *  than those supported by the POV-Ray Team.  There are strict rules under
  16. *  which you are permitted to use this file.  The rules are in the file
  17. *  named POVLEGAL.DOC which should be distributed with this file. If 
  18. *  POVLEGAL.DOC is not available or for more info please contact the POV-Ray
  19. *  Team Coordinator by leaving a message in CompuServe's Graphics Developer's
  20. *  Forum.  The latest version of POV-Ray may be found there as well.
  21. *
  22. * This program is based on the popular DKB raytracer version 2.12.
  23. * DKBTrace was originally written by David K. Buck.
  24. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  25. *
  26. *****************************************************************************/
  27.  
  28. /*
  29.    Some texture ideas garnered from SIGGRAPH '85 Volume 19 Number 3, 
  30.    "An Image Synthesizer" By Ken Perlin.
  31.    Further Ideas Garnered from "The RenderMan Companion" (Addison Wesley)
  32. */
  33.  
  34. #include "frame.h"
  35. #include "povray.h"
  36. #include "vector.h"
  37. #include "povproto.h"
  38. #include "texture.h"
  39. #include "halos.h"
  40. #include "image.h"
  41. #include "matrices.h"
  42. #include "normal.h"
  43. #include "pigment.h"
  44.  
  45.  
  46.  
  47. /*****************************************************************************
  48. * Local preprocessor defines
  49. ******************************************************************************/
  50.  
  51. /* Ridiculously large scaling values */
  52.  
  53. #define MINX (-10000)
  54. #define MINY MINX
  55. #define MINZ MINX
  56.  
  57. #define SINTABSIZE 1000
  58.  
  59. #define REALSCALE (2.0 / 65535.0)
  60.  
  61. #define SCURVE(a) ((a)*(a)*(3.0-2.0*(a)))
  62.  
  63.  
  64. /*****************************************************************************
  65. * Local typedefs
  66. ******************************************************************************/
  67.  
  68.  
  69.  
  70. /*****************************************************************************
  71. * Local variables
  72. ******************************************************************************/
  73.  
  74. static DBL *sintab;
  75. unsigned int Number_Of_Waves = 10;    /* dmf */
  76. DBL *frequency;                       /* dmf */
  77. VECTOR *Wave_Sources;                 /* dmf */
  78.  
  79. short *hashTable;
  80.  
  81. DBL RTable[267] =
  82. {
  83.          -1,    0.604974,   -0.937102,    0.414115,    0.576226,  -0.0161593,
  84.    0.432334,    0.103685,    0.590539,   0.0286412,     0.46981,    -0.84622,
  85.  -0.0734112,   -0.304097,    -0.40206,   -0.210132,   -0.919127,    0.652033,
  86.    -0.83151,   -0.183948,   -0.671107,    0.852476,    0.043595,   -0.404532,
  87.     0.75494,   -0.335653,    0.618433,    0.605707,    0.708583,   -0.477195,
  88.    0.899474,    0.490623,    0.221729,   -0.400381,   -0.853727,   -0.932586,
  89.    0.659113,    0.961303,    0.325948,   -0.750851,    0.842466,    0.734401,
  90.   -0.649866,    0.394491,   -0.466056,   -0.434073,    0.109026,   0.0847028,
  91.   -0.738857,    0.241505,     0.16228,    -0.71426,   -0.883665,   -0.150408,
  92.    -0.90396,   -0.686549,   -0.785214,    0.488548,   0.0246433,    0.142473,
  93.   -0.602136,    0.375845, -0.00779736,    0.498955,   -0.268147,    0.856382,
  94.   -0.386007,   -0.596094,   -0.867735,   -0.570977,   -0.914366,     0.28896,
  95.    0.672206,   -0.233783,     0.94815,    0.895262,    0.343252,   -0.173388,
  96.   -0.767971,   -0.314748,    0.824308,   -0.342092,    0.721431,    -0.24004,
  97.    -0.63653,    0.553277,    0.376272,    0.158984,   -0.452659,    0.396323,
  98.   -0.420676,   -0.454154,    0.122179,    0.295857,   0.0664225,   -0.202075,
  99.   -0.724788,    0.453513,    0.224567,   -0.908812,    0.176349,   -0.320516,
  100.   -0.697139,    0.742702,   -0.900786,    0.471489,   -0.133532,    0.119127,
  101.   -0.889769,    -0.23183,   -0.669673,   -0.046891,   -0.803433,   -0.966735,
  102.    0.475578,   -0.652644,   0.0112459,   -0.730007,    0.128283,    0.145647,
  103.   -0.619318,    0.272023,    0.392966,    0.646418,  -0.0207675,   -0.315908,
  104.    0.480797,    0.535668,   -0.250172,    -0.83093,   -0.653773,   -0.443809,
  105.    0.119982,   -0.897642,     0.89453,    0.165789,    0.633875,   -0.886839,
  106.    0.930877,   -0.537194,    0.587732,    0.722011,   -0.209461,  -0.0424659,
  107.   -0.814267,   -0.919432,    0.280262,    -0.66302,   -0.558099,   -0.537469,
  108.   -0.598779,    0.929656,   -0.170794,   -0.537163,    0.312581,    0.959442,
  109.    0.722652,    0.499931,    0.175616,   -0.534874,   -0.685115,    0.444999,
  110.     0.17171,    0.108202,   -0.768704,   -0.463828,    0.254231,    0.546014,
  111.    0.869474,    0.875212,   -0.944427,    0.130724,   -0.110185,    0.312184,
  112.    -0.33138,   -0.629206,   0.0606546,    0.722866,  -0.0979477,    0.821561,
  113.   0.0931258,   -0.972808,   0.0318151,   -0.867033,   -0.387228,    0.280995,
  114.   -0.218189,   -0.539178,   -0.427359,   -0.602075,    0.311971,    0.277974,
  115.    0.773159,    0.592493,  -0.0331884,   -0.630854,   -0.269947,    0.339132,
  116.    0.581079,    0.209461,   -0.317433,   -0.284993,    0.181323,    0.341634,
  117.    0.804959,   -0.229572,   -0.758907,   -0.336721,    0.605463,   -0.991272,
  118.  -0.0188754,   -0.300191,    0.368307,   -0.176135,     -0.3832,   -0.749569,
  119.     0.62356,   -0.573938,    0.278309,   -0.971313,    0.839994,   -0.830686,
  120.    0.439078,     0.66128,    0.694514,   0.0565042,     0.54342,   -0.438804,
  121.  -0.0228428,   -0.687068,    0.857267,    0.301991,   -0.494255,   -0.941039,
  122.    0.775509,    0.410575,   -0.362081,   -0.671534,   -0.348379,    0.932433,
  123.    0.886442,    0.868681,   -0.225666,   -0.062211,  -0.0976425,   -0.641444,
  124.   -0.848112,    0.724697,    0.473503,    0.998749,    0.174701,    0.559625,
  125.   -0.029099,   -0.337392,   -0.958129,   -0.659785,    0.236042,   -0.246937,
  126.    0.659449,   -0.027512,    0.821897,   -0.226215,   0.0181735,    0.500481,
  127.   -0.420127,   -0.427878,    0.566186
  128. };
  129.  
  130. static unsigned long int next_rand = 1;
  131.  
  132.  
  133.  
  134. /*****************************************************************************
  135. * Static functions
  136. ******************************************************************************/
  137.  
  138. static void InitTextureTable PARAMS((void));
  139. static TEXTURE *Copy_Materials PARAMS((TEXTURE *Old));
  140.  
  141.  
  142. /*****************************************************************************
  143. *
  144. * FUNCTION
  145. *
  146. *   Initialize_Noise()
  147. *
  148. * INPUT
  149. *   
  150. * OUTPUT
  151. *
  152. * RETURNS
  153. *   
  154. * AUTHOR
  155. *
  156. *   POV-Ray Team
  157. *   
  158. * DESCRIPTION
  159. *
  160. * CHANGES
  161. *
  162. ******************************************************************************/
  163.  
  164. void Initialize_Noise()
  165. {
  166.   register unsigned int i;
  167.   VECTOR point;
  168.  
  169.   InitTextureTable();
  170.  
  171.   sintab = (DBL *)POV_MALLOC(SINTABSIZE * sizeof(DBL), "sine table");
  172.  
  173.   /* dmf */
  174.   frequency = (DBL *)POV_MALLOC(Number_Of_Waves * sizeof(DBL), "wave frequency table: use lower Number_Of_Waves");
  175.  
  176.   /* dmf */
  177.   Wave_Sources = (VECTOR *)POV_MALLOC(Number_Of_Waves * sizeof(VECTOR), "wave sources table: use lower Number_Of_Waves");
  178.  
  179.   for (i = 0 ; i < SINTABSIZE ; i++)
  180.   {
  181.     sintab[i] = sin((DBL)i / SINTABSIZE * M_PI * 2.0);
  182.   }
  183.  
  184.   for (i = 0 ; i < Number_Of_Waves ; i++)
  185.   {
  186.     Make_Vector(point,(DBL)i,0.0,0.0);
  187.     DNoise(point, point);
  188.     VNormalize(Wave_Sources[i], point);
  189.     frequency[i] = FRAND() + 0.01;
  190.   }
  191. }
  192.  
  193.  
  194.  
  195. /*****************************************************************************
  196. *
  197. * FUNCTION
  198. *
  199. *   InitTextureTable()
  200. *
  201. * INPUT
  202. *
  203. * OUTPUT
  204. *
  205. * RETURNS
  206. *
  207. * AUTHOR
  208. *
  209. *   POV-Ray Team
  210. *
  211. * DESCRIPTION
  212. *
  213. * CHANGES
  214. *
  215. ******************************************************************************/
  216.  
  217. static void InitTextureTable()
  218. {
  219.   int i, j, temp;
  220.  
  221.   POV_SRAND(0);
  222.  
  223.   hashTable = (short int *)POV_MALLOC(4096*sizeof(short int), "hash table");
  224.  
  225.   for (i = 0; i < 4096; i++)
  226.   {
  227.     hashTable[i] = i;
  228.   }
  229.  
  230.   for (i = 4095; i >= 0; i--)
  231.   {
  232.     j = POV_RAND() % 4096;
  233.     temp = hashTable[i];
  234.     hashTable[i] = hashTable[j];
  235.     hashTable[j] = temp;
  236.   }
  237. }
  238.  
  239.  
  240.  
  241. /*****************************************************************************
  242. *
  243. * FUNCTION
  244. *
  245. *   Free_Noise_Tables()
  246. *
  247. * INPUT
  248. *   
  249. * OUTPUT
  250. *   
  251. * RETURNS
  252. *   
  253. * AUTHOR
  254. *
  255. *   POV-Ray Team
  256. *   
  257. * DESCRIPTION
  258. *
  259. * CHANGES
  260. *
  261. ******************************************************************************/
  262.  
  263. void Free_Noise_Tables()
  264. {
  265.   if (sintab != NULL) 
  266.   {
  267.     POV_FREE(sintab);
  268.     POV_FREE(hashTable);
  269.     POV_FREE(frequency);
  270.     POV_FREE(Wave_Sources);
  271.     
  272.     sintab       = NULL;
  273.     hashTable    = NULL;
  274.     frequency    = NULL;
  275.     Wave_Sources = NULL;
  276.   }
  277. }
  278.  
  279.  
  280.  
  281. /*****************************************************************************
  282. *
  283. * FUNCTION
  284. *
  285. *   Noise
  286. *
  287. * INPUT
  288. *
  289. *   EPoint -- 3-D point at which noise is evaluated
  290. *
  291. * OUTPUT
  292. *   
  293. * RETURNS
  294. *
  295. *   DBL noise value
  296. *   
  297. * AUTHOR
  298. *
  299. *   Robert Skinner based on Ken Perlin
  300. *   
  301. * DESCRIPTION
  302. *
  303. * CHANGES
  304. *   Modified by AAC to ensure uniformly distributed clamped values
  305. *   between 0 and 1.0...
  306. *
  307. ******************************************************************************/
  308.  
  309. DBL Noise(EPoint)
  310. VECTOR EPoint;
  311. {
  312.   DBL x, y, z;
  313.   DBL *mp;
  314.   long ix, iy, iz, jx, jy, jz;
  315.   int ixiy_hash, ixjy_hash, jxiy_hash, jxjy_hash;
  316.   
  317.   DBL sx, sy, sz, tx, ty, tz;
  318.   DBL sum;
  319.   
  320.   DBL x_ix, x_jx, y_iy, y_jy, z_iz, z_jz, txty, sxty, txsy, sxsy;
  321.   
  322.   Increase_Counter(stats[Calls_To_Noise]);
  323.   
  324.   x = EPoint[X]-MINX;
  325.   y = EPoint[Y]-MINY;
  326.   z = EPoint[Z]-MINZ;
  327.   
  328.   /* its equivalent integer lattice point. */
  329.   ix = (long)x; iy = (long)y; iz = (long)z;
  330.   jx = ix + 1; jy = iy + 1; jz = iz + 1;
  331.   
  332.   sx = SCURVE(x - ix); sy = SCURVE(y - iy); sz = SCURVE(z - iz);
  333.   
  334.   /* the complement values of sx,sy,sz */
  335.   tx = 1.0 - sx; ty = 1.0 - sy; tz = 1.0 - sz;
  336.   
  337.   /*
  338.   *  interpolate!
  339.   */
  340.   x_ix = x - ix;
  341.   x_jx = x - jx;
  342.   y_iy = y - iy;
  343.   y_jy = y - jy;
  344.   z_iz = z - iz;
  345.   z_jz = z - jz;
  346.   txty = tx * ty;
  347.   sxty = sx * ty;
  348.   txsy = tx * sy;
  349.   sxsy = sx * sy;
  350.   ixiy_hash = Hash2d(ix, iy);
  351.   jxiy_hash = Hash2d(jx, iy);
  352.   ixjy_hash = Hash2d(ix, jy);
  353.   jxjy_hash = Hash2d(jx, jy);
  354.   
  355.   mp = &RTable[(int) Hash1d(ixiy_hash, iz) & 0xFF];
  356.   sum = INCRSUMP(mp, (txty*tz), x_ix, y_iy, z_iz);
  357.   
  358.   mp = &RTable[(int) Hash1d(jxiy_hash, iz) & 0xFF];
  359.   sum += INCRSUMP(mp, (sxty*tz), x_jx, y_iy, z_iz);
  360.   
  361.   mp = &RTable[(int) Hash1d(ixjy_hash, iz) & 0xFF];
  362.   sum += INCRSUMP(mp, (txsy*tz), x_ix, y_jy, z_iz);
  363.   
  364.   mp = &RTable[(int) Hash1d(jxjy_hash, iz) & 0xFF];
  365.   sum += INCRSUMP(mp, (sxsy*tz), x_jx, y_jy, z_iz);
  366.   
  367.   mp = &RTable[(int) Hash1d(ixiy_hash, jz) & 0xFF];
  368.   sum += INCRSUMP(mp, (txty*sz), x_ix, y_iy, z_jz);
  369.   
  370.   mp = &RTable[(int) Hash1d(jxiy_hash, jz) & 0xFF];
  371.   sum += INCRSUMP(mp, (sxty*sz), x_jx, y_iy, z_jz);
  372.  
  373.   mp = &RTable[(int) Hash1d(ixjy_hash, jz) & 0xFF];
  374.   sum += INCRSUMP(mp, (txsy*sz), x_ix, y_jy, z_jz);
  375.   
  376.   mp = &RTable[(int) Hash1d(jxjy_hash, jz) & 0xFF];
  377.   sum += INCRSUMP(mp, (sxsy*sz), x_jx, y_jy, z_jz);
  378.   
  379.   sum = sum + 0.5;                     /* range at this point -0.5 - 0.5... */
  380.   
  381.   if (sum < 0.0)
  382.     sum = 0.0;
  383.   if (sum > 1.0)
  384.     sum = 1.0;
  385.   
  386.   return (sum);
  387. }
  388.  
  389.  
  390.  
  391. /*****************************************************************************
  392. *
  393. * FUNCTION
  394. *
  395. *   DNoise
  396. *
  397. * INPUT
  398. *
  399. *   EPoint -- 3-D point at which noise is evaluated
  400. *   
  401. * OUTPUT
  402. *
  403. *   VECTOR result
  404. *   
  405. * RETURNS
  406. *   
  407. * AUTHOR
  408. *
  409. *   Robert Skinner based on Ken Perlin
  410. *   
  411. * DESCRIPTION
  412. *   Vector-valued version of "Noise"
  413. *
  414. * CHANGES
  415. *   Modified by AAC to ensure uniformly distributed clamped values
  416. *   between 0 and 1.0...
  417. *
  418. ******************************************************************************/
  419.  
  420. void DNoise(result, EPoint)
  421. VECTOR result;
  422. VECTOR EPoint;
  423. {
  424.   DBL x, y, z;
  425.   DBL *mp;
  426.   long ix, iy, iz, jx, jy, jz;
  427.   int ixiy_hash, ixjy_hash, jxiy_hash, jxjy_hash;
  428.   DBL px, py, pz, s;
  429.   DBL sx, sy, sz, tx, ty, tz;
  430.   DBL txty, sxty, txsy, sxsy;
  431.   
  432.   Increase_Counter(stats[Calls_To_DNoise]);
  433.   
  434.   x = EPoint[X]-MINX;
  435.   y = EPoint[Y]-MINY;
  436.   z = EPoint[Z]-MINZ;
  437.   
  438.   /* its equivalent integer lattice point. */
  439.   ix = (long)x; iy = (long)y; iz = (long)z;
  440.   jx = ix + 1; jy = iy + 1; jz = iz + 1;
  441.   
  442.   sx = SCURVE(x - ix); sy = SCURVE(y - iy); sz = SCURVE(z - iz);
  443.   
  444.   /* the complement values of sx,sy,sz */
  445.   tx = 1.0 - sx; ty = 1.0 - sy; tz = 1.0 - sz;
  446.   
  447.   /*
  448.   *  interpolate!
  449.   */
  450.   txty = tx * ty;
  451.   sxty = sx * ty;
  452.   txsy = tx * sy;
  453.   sxsy = sx * sy;
  454.   ixiy_hash = Hash2d(ix, iy);
  455.   jxiy_hash = Hash2d(jx, iy);
  456.   ixjy_hash = Hash2d(ix, jy);
  457.   jxjy_hash = Hash2d(jx, jy);
  458.   
  459.   mp = &RTable[(int) Hash1d(ixiy_hash, iz) & 0xFF];
  460.   px = x - ix;  py = y - iy;  pz = z - iz;
  461.   s = txty*tz;
  462.   result[X] = INCRSUMP(mp, s, px, py, pz);
  463.   mp += 4;
  464.   result[Y] = INCRSUMP(mp, s, px, py, pz);
  465.   mp += 4;
  466.   result[Z] = INCRSUMP(mp, s, px, py, pz);
  467.   
  468.   mp = &RTable[(int) Hash1d(jxiy_hash, iz) & 0xFF];
  469.   px = x - jx;
  470.   s = sxty*tz;
  471.   result[X] += INCRSUMP(mp, s, px, py, pz);
  472.   mp += 4;
  473.   result[Y] += INCRSUMP(mp, s, px, py, pz);
  474.   mp += 4;
  475.   result[Z] += INCRSUMP(mp, s, px, py, pz);
  476.   
  477.   mp = &RTable[(int) Hash1d(jxjy_hash, iz) & 0xFF];
  478.   py = y - jy;
  479.   s = sxsy*tz;
  480.   result[X] += INCRSUMP(mp, s, px, py, pz);
  481.   mp += 4;
  482.   result[Y] += INCRSUMP(mp, s, px, py, pz);
  483.   mp += 4;
  484.   result[Z] += INCRSUMP(mp, s, px, py, pz);
  485.   
  486.   mp = &RTable[(int) Hash1d(ixjy_hash, iz) & 0xFF];
  487.   px = x - ix;
  488.   s = txsy*tz;
  489.   result[X] += INCRSUMP(mp, s, px, py, pz);
  490.   mp += 4;
  491.   result[Y] += INCRSUMP(mp, s, px, py, pz);
  492.   mp += 4;
  493.   result[Z] += INCRSUMP(mp, s, px, py, pz);
  494.   
  495.   mp = &RTable[(int) Hash1d(ixjy_hash, jz) & 0xFF];
  496.   pz = z - jz;
  497.   s = txsy*sz;
  498.   result[X] += INCRSUMP(mp, s, px, py, pz);
  499.   mp += 4;
  500.   result[Y] += INCRSUMP(mp, s, px, py, pz);
  501.   mp += 4;
  502.   result[Z] += INCRSUMP(mp, s, px, py, pz);
  503.   
  504.   mp = &RTable[(int) Hash1d(jxjy_hash, jz) & 0xFF];
  505.   px = x - jx;
  506.   s = sxsy*sz;
  507.   result[X] += INCRSUMP(mp, s, px, py, pz);
  508.   mp += 4;
  509.   result[Y] += INCRSUMP(mp, s, px, py, pz);
  510.   mp += 4;
  511.   result[Z] += INCRSUMP(mp, s, px, py, pz);
  512.   
  513.   mp = &RTable[(int) Hash1d(jxiy_hash, jz) & 0xFF];
  514.   py = y - iy;
  515.   s = sxty*sz;
  516.   result[X] += INCRSUMP(mp, s, px, py, pz);
  517.   mp += 4;
  518.   result[Y] += INCRSUMP(mp, s, px, py, pz);
  519.   mp += 4;
  520.   result[Z] += INCRSUMP(mp, s, px, py, pz);
  521.   
  522.   mp = &RTable[(int) Hash1d(ixiy_hash, jz) & 0xFF];
  523.   px = x - ix;
  524.   s = txty*sz;
  525.   result[X] += INCRSUMP(mp, s, px, py, pz);
  526.   mp += 4;
  527.   result[Y] += INCRSUMP(mp, s, px, py, pz);
  528.   mp += 4;
  529.   result[Z] += INCRSUMP(mp, s, px, py, pz);
  530. }
  531.  
  532.  
  533.  
  534. /*****************************************************************************
  535. *
  536. * FUNCTION
  537. *
  538. *   Turbulence
  539. *
  540. * INPUT
  541. *
  542. *   EPoint -- Point at which turb is evaluated.
  543. *   Turb   -- Parameters for fmb calculations.
  544. *   
  545. * OUTPUT
  546. *   
  547. * RETURNS
  548. *
  549. *   DBL result
  550. *   
  551. * AUTHOR
  552. *
  553. *   POV-Ray Team
  554. *
  555. * DESCRIPTION   : Computes a Fractal Brownian Motion turbulence value
  556. *                 using repeated calls to a Perlin Noise function.
  557. *
  558. * CHANGES
  559. *   ??? ???? : Updated with varible Octaves, Lambda, & Omega by [DMF]
  560. *
  561. ******************************************************************************/
  562.  
  563. DBL Turbulence(EPoint,Turb)
  564. VECTOR EPoint;
  565. TURB *Turb;
  566. {
  567.   int i;
  568.   DBL Lambda, Omega, l, o, value;
  569.   VECTOR temp;
  570.   int Octaves=Turb->Octaves;
  571.   
  572.   value = Noise(EPoint);
  573.  
  574.   l = Lambda = Turb->Lambda;
  575.   o = Omega  = Turb->Omega;
  576.  
  577.   for (i = 2; i <= Octaves; i++)
  578.   {
  579.     VScale(temp,EPoint,l);
  580.     value += o * Noise(temp);
  581.     if (i < Octaves)
  582.     {
  583.       l *= Lambda;
  584.       o *= Omega;
  585.     }
  586.   }
  587.   return (value);
  588. }
  589.  
  590.  
  591.  
  592. /*****************************************************************************
  593. *
  594. * FUNCTION
  595. *
  596. *   DTurbulence
  597. *
  598. * INPUT
  599. *
  600. *   EPoint -- Point at which turb is evaluated.
  601. *   Turb   -- Parameters for fmb calculations.
  602. *   
  603. * OUTPUT
  604. *
  605. *   result -- Vector valued turbulence
  606. *   
  607. * RETURNS
  608. *   
  609. * AUTHOR
  610. *
  611. *   POV-Ray Team
  612. *   
  613. * DESCRIPTION   : Computes a Fractal Brownian Motion turbulence value
  614. *                 using repeated calls to a Perlin DNoise function.
  615. *
  616. * CHANGES
  617. *   ??? ???? : Updated with varible Octaves, Lambda, & Omega by [DMF]
  618. *
  619. ******************************************************************************/
  620.  
  621.  
  622. void DTurbulence(result, EPoint, Turb)
  623. VECTOR  result, EPoint;
  624. TURB *Turb;
  625. {
  626.   DBL Omega, Lambda;
  627.   int i;
  628.   DBL l, o;
  629.   VECTOR value, temp;
  630.   int Octaves=Turb->Octaves;
  631.   
  632.   result[X] = result[Y] = result[Z] = 0.0;
  633.   value[X]  = value[Y]  = value[Z]  = 0.0;
  634.   
  635.   DNoise(result, EPoint);
  636.   
  637.   l = Lambda = Turb->Lambda;
  638.   o = Omega  = Turb->Omega;
  639.  
  640.   for (i = 2; i <= Octaves; i++)
  641.   {
  642.     VScale(temp,EPoint,l);
  643.     
  644.     DNoise(value, temp);
  645.     result[X] += o * value[X];
  646.     result[Y] += o * value[Y];
  647.     result[Z] += o * value[Z];
  648.     if (i < Octaves)
  649.     {
  650.       l *= Lambda;
  651.       o *= Omega;
  652.     }
  653.   }
  654. }
  655.  
  656.  
  657.  
  658. /*****************************************************************************
  659. *
  660. * FUNCTION
  661. *
  662. *   cycloidal
  663. *
  664. * INPUT
  665. *
  666. *   DBL value
  667. *   
  668. * OUTPUT
  669. *   
  670. * RETURNS
  671. *
  672. *   DBL result
  673. *   
  674. * AUTHOR
  675. *
  676. *   POV-Ray Team
  677. *   
  678. * DESCRIPTION
  679. *
  680. * CHANGES
  681. *
  682. ******************************************************************************/
  683.  
  684. DBL cycloidal(value)
  685. DBL value;
  686. {
  687.   register int indx;
  688.   
  689.   if (value >= 0.0)
  690.   {
  691.     indx = (int)((value - floor(value)) * SINTABSIZE);
  692.     return (sintab [indx]);
  693.   }
  694.   else
  695.   {
  696.     indx = (int)((0.0 - (value + floor(0.0 - value))) * SINTABSIZE);
  697.     return (0.0 - sintab [indx]);
  698.   }
  699. }
  700.  
  701.  
  702.  
  703. /*****************************************************************************
  704. *
  705. * FUNCTION
  706. *
  707. *   Triangle_Wave
  708. *
  709. * INPUT
  710. *
  711. *   DBL value
  712. *   
  713. * OUTPUT
  714. *   
  715. * RETURNS
  716. *
  717. *   DBL result
  718. *   
  719. * AUTHOR
  720. *
  721. *   POV-Ray Team
  722. *   
  723. * DESCRIPTION
  724. *
  725. * CHANGES
  726. *
  727. ******************************************************************************/
  728.  
  729. DBL Triangle_Wave(value)
  730. DBL value;
  731. {
  732.   register DBL offset;
  733.   
  734.   if (value >= 0.0) 
  735.   {
  736.     offset = value - floor(value);
  737.   }
  738.   else
  739.   {
  740.     offset = value + 1.0 + floor(fabs(value));
  741.   }
  742.   if (offset >= 0.5) 
  743.   {
  744.     return (2.0 * (1.0 - offset));
  745.   }
  746.   else
  747.   {
  748.     return (2.0 * offset);
  749.   }
  750. }
  751.  
  752.  
  753.  
  754. /*****************************************************************************
  755. *
  756. * FUNCTION
  757. *
  758. * INPUT
  759. *   
  760. * OUTPUT
  761. *   
  762. * RETURNS
  763. *   
  764. * AUTHOR
  765. *
  766. *   POV-Ray Team
  767. *   
  768. * DESCRIPTION
  769. *
  770. * CHANGES
  771. *
  772. ******************************************************************************/
  773.  
  774. void Translate_Textures(Textures, Trans)
  775. TEXTURE *Textures;
  776. TRANSFORM *Trans;
  777. {
  778.   Transform_Textures(Textures, Trans);
  779. }
  780.  
  781.  
  782.  
  783. /*****************************************************************************
  784. *
  785. * FUNCTION
  786. *
  787. * INPUT
  788. *   
  789. * OUTPUT
  790. *   
  791. * RETURNS
  792. *   
  793. * AUTHOR
  794. *
  795. *   POV-Ray Team
  796. *
  797. * DESCRIPTION
  798. *
  799. * CHANGES
  800. *
  801. ******************************************************************************/
  802.  
  803. void Rotate_Textures(Textures, Trans)
  804. TEXTURE *Textures;
  805. TRANSFORM *Trans;
  806. {
  807.   Transform_Textures(Textures, Trans);
  808. }
  809.  
  810.  
  811.  
  812. /*****************************************************************************
  813. *
  814. * FUNCTION
  815. *
  816. * INPUT
  817. *
  818. * OUTPUT
  819. *
  820. * RETURNS
  821. *
  822. * AUTHOR
  823. *
  824. *   POV-Ray Team
  825. *
  826. * DESCRIPTION
  827. *
  828. * CHANGES
  829. *
  830. ******************************************************************************/
  831.  
  832. void Scale_Textures(Textures, Trans)
  833. TEXTURE *Textures;
  834. TRANSFORM *Trans;
  835. {
  836.   Transform_Textures(Textures, Trans);
  837. }
  838.  
  839.  
  840.  
  841. /*****************************************************************************
  842. *
  843. * FUNCTION
  844. *
  845. * INPUT
  846. *
  847. * OUTPUT
  848. *
  849. * RETURNS
  850. *
  851. * AUTHOR
  852. *
  853. *   POV-Ray Team
  854. *
  855. * DESCRIPTION
  856. *
  857. * CHANGES
  858. *
  859. ******************************************************************************/
  860.  
  861. void Transform_Textures(Textures, Trans)
  862. TEXTURE *Textures;
  863. TRANSFORM *Trans;
  864. {
  865.   TEXTURE *Layer;
  866.  
  867.   for (Layer = Textures; Layer != NULL; Layer = (TEXTURE *)Layer->Next)
  868.   {
  869.     if (Layer->Type == PLAIN_PATTERN)
  870.     {
  871.       Transform_Tpattern((TPATTERN *)Layer->Pigment, Trans);
  872.       Transform_Tpattern((TPATTERN *)Layer->Tnormal, Trans);
  873.       Transform_Halo(Layer->Halo, Trans);
  874.     }
  875.     else
  876.     {
  877.       Transform_Tpattern((TPATTERN *)Layer, Trans);
  878.     }
  879.   }
  880. }
  881.  
  882.  
  883.  
  884. /*****************************************************************************
  885. *
  886. * FUNCTION
  887. *
  888. * INPUT
  889. *
  890. * OUTPUT
  891. *
  892. * RETURNS
  893. *
  894. * AUTHOR
  895. *
  896. *   POV-Ray Team
  897. *   
  898. * DESCRIPTION
  899. *
  900. * CHANGES
  901. *
  902. ******************************************************************************/
  903.  
  904. FINISH *Create_Finish()
  905. {
  906.   FINISH *New;
  907.   
  908.   New = (FINISH *)POV_MALLOC(sizeof (FINISH), "finish");
  909.   
  910.   Make_RGB(New->Ambient, 0.1, 0.1, 0.1);
  911.   Make_RGB(New->Reflection, 0.0, 0.0, 0.0);
  912.  
  913.   New->Diffuse    = 0.6;
  914.   New->Brilliance = 1.0;
  915.   New->Phong      = 0.0;
  916.   New->Phong_Size = 40.0;
  917.   New->Specular   = 0.0;
  918.   New->Roughness  = 1.0 / 0.05;
  919.   New->Refraction = 0.0;
  920.  
  921.   New->Index_Of_Refraction = 1.0;
  922.  
  923.   New->Crand = 0.0;
  924.  
  925.   New->Metallic = 0.0;
  926.   New->Caustics = 0.0;
  927.  
  928.   New->Irid                = 0.0;
  929.   New->Irid_Film_Thickness = 0.0;
  930.   New->Irid_Turb           = 0.0;
  931.  
  932.   New->Fade_Distance = 0.0;
  933.   New->Fade_Power    = 0.0;
  934.  
  935.   return(New);
  936. }
  937.  
  938.  
  939.  
  940. /*****************************************************************************
  941. *
  942. * FUNCTION
  943. *
  944. * INPUT
  945. *   
  946. * OUTPUT
  947. *   
  948. * RETURNS
  949. *   
  950. * AUTHOR
  951. *
  952. *   POV-Ray Team
  953. *   
  954. * DESCRIPTION
  955. *
  956. * CHANGES
  957. *
  958. ******************************************************************************/
  959.  
  960. FINISH *Copy_Finish(Old)
  961. FINISH *Old;
  962. {
  963.   FINISH *New;
  964.   
  965.   if (Old != NULL)
  966.   {
  967.     New = Create_Finish();
  968.     *New = *Old;
  969.   }
  970.   else
  971.     New = NULL;
  972.   return (New);
  973. }
  974.  
  975.  
  976.  
  977. /*****************************************************************************
  978. *
  979. * FUNCTION
  980. *
  981. * INPUT
  982. *   
  983. * OUTPUT
  984. *   
  985. * RETURNS
  986. *   
  987. * AUTHOR
  988. *
  989. *   POV-Ray Team
  990. *   
  991. * DESCRIPTION
  992. *
  993. * CHANGES
  994. *
  995. ******************************************************************************/
  996.  
  997. TEXTURE *Create_Texture()
  998. {
  999.   TEXTURE *New;
  1000.   
  1001.   New = (TEXTURE *)POV_MALLOC(sizeof (TEXTURE), "texture");
  1002.   
  1003.   Init_TPat_Fields((TPATTERN *)New);
  1004.  
  1005.   New->References = 1;
  1006.  
  1007.   New->Type  = PLAIN_PATTERN;
  1008.   New->Flags = NO_FLAGS;
  1009.  
  1010.   New->Pigment = NULL;
  1011.   New->Tnormal = NULL;
  1012.   New->Finish  = NULL;
  1013.   New->Halo    = NULL;
  1014.  
  1015.   New->Next          = NULL;
  1016.   New->Next_Material = NULL;
  1017.  
  1018.   return (New);
  1019. }
  1020.  
  1021.  
  1022. /*****************************************************************************
  1023. *
  1024. * FUNCTION
  1025. *
  1026. * INPUT
  1027. *   
  1028. * OUTPUT
  1029. *   
  1030. * RETURNS
  1031. *   
  1032. * AUTHOR
  1033. *
  1034. *   POV-Ray Team
  1035. *   
  1036. * DESCRIPTION
  1037. *
  1038. * CHANGES
  1039. *
  1040. ******************************************************************************/
  1041.  
  1042. TEXTURE *Copy_Texture_Pointer(Texture)
  1043. TEXTURE *Texture;
  1044. {
  1045.   if (Texture != NULL)
  1046.   {
  1047.     Texture->References++;
  1048.   }
  1049.  
  1050.   return(Texture);
  1051. }
  1052.  
  1053.  
  1054.  
  1055.  
  1056. /*****************************************************************************
  1057. *
  1058. * FUNCTION
  1059. *
  1060. * INPUT
  1061. *   
  1062. * OUTPUT
  1063. *   
  1064. * RETURNS
  1065. *   
  1066. * AUTHOR
  1067. *
  1068. *   POV-Ray Team
  1069. *   
  1070. * DESCRIPTION
  1071. *
  1072. * CHANGES
  1073. *
  1074. ******************************************************************************/
  1075.  
  1076. TEXTURE *Copy_Textures(Textures)
  1077. TEXTURE *Textures;
  1078. {
  1079.   TEXTURE *New, *First, *Previous, *Layer;
  1080.   
  1081.   Previous = First = NULL;
  1082.   
  1083.   for (Layer = Textures; Layer != NULL; Layer = (TEXTURE *)Layer->Next)
  1084.   {
  1085.     New = Create_Texture();
  1086.     Copy_TPat_Fields ((TPATTERN *)New, (TPATTERN *)Layer);
  1087.  
  1088.     switch (Layer->Type)
  1089.     {
  1090.       case PLAIN_PATTERN:
  1091.         New->Pigment = Copy_Pigment(Layer->Pigment);
  1092.         New->Tnormal = Copy_Tnormal(Layer->Tnormal);
  1093.         New->Finish  = Copy_Finish(Layer->Finish);
  1094.         New->Halo    = Copy_Halo(Layer->Halo);
  1095.  
  1096.         break;
  1097.       
  1098.       case BITMAP_PATTERN:
  1099.  
  1100.         New->Materials   = Copy_Materials(Layer->Materials);
  1101.         New->Num_Of_Mats = Layer->Num_Of_Mats;
  1102.  
  1103. /*      Not needed. Copied by Copy_TPat_Fields */
  1104. /*      New->Vals.Image  = Copy_Image(Layer->Vals.Image);*/ 
  1105.  
  1106.         break;
  1107.     }
  1108.  
  1109.     if (First == NULL)
  1110.     {
  1111.       First = New;
  1112.     }
  1113.  
  1114.     if (Previous != NULL)
  1115.     {
  1116.       Previous->Next = (TPATTERN *)New;
  1117.     }
  1118.  
  1119.     Previous = New;
  1120.   }
  1121.  
  1122.   return (First);
  1123. }
  1124.  
  1125.  
  1126.  
  1127. /*****************************************************************************
  1128. *
  1129. * FUNCTION
  1130. *
  1131. * INPUT
  1132. *   
  1133. * OUTPUT
  1134. *   
  1135. * RETURNS
  1136. *   
  1137. * AUTHOR
  1138. *
  1139. *   POV-Ray Team
  1140. *   
  1141. * DESCRIPTION
  1142. *
  1143. * CHANGES
  1144. *
  1145. ******************************************************************************/
  1146.  
  1147. static TEXTURE *Copy_Materials(Old)
  1148. TEXTURE *Old;
  1149. {
  1150.   TEXTURE *New, *First, *Previous, *Material;
  1151.   
  1152.   Previous = First = NULL;
  1153.   
  1154.   for (Material = Old; Material != NULL; Material = Material->Next_Material)
  1155.   {
  1156.     New = Copy_Textures(Material);
  1157.  
  1158.     if (First == NULL)
  1159.     {
  1160.       First = New;
  1161.     }
  1162.  
  1163.     if (Previous != NULL)
  1164.     {
  1165.       Previous->Next_Material = New;
  1166.     }
  1167.  
  1168.     Previous = New;
  1169.   }
  1170.  
  1171.   return (First);
  1172. }
  1173.  
  1174.  
  1175.  
  1176. /*****************************************************************************
  1177. *
  1178. * FUNCTION
  1179. *
  1180. * INPUT
  1181. *   
  1182. * OUTPUT
  1183. *   
  1184. * RETURNS
  1185. *   
  1186. * AUTHOR
  1187. *
  1188. *   POV-Ray Team
  1189. *   
  1190. * DESCRIPTION
  1191. *
  1192. * CHANGES
  1193. *
  1194. ******************************************************************************/
  1195.  
  1196. void Destroy_Textures(Textures)
  1197. TEXTURE *Textures;
  1198. {
  1199.   TEXTURE *Layer = Textures;
  1200.   TEXTURE *Mats;
  1201.   TEXTURE *Temp;
  1202.   
  1203.   if ((Textures == NULL) || (--(Textures->References) > 0))
  1204.   {
  1205.     return;
  1206.   }
  1207.  
  1208.   while (Layer != NULL)
  1209.   {
  1210.     Mats = Layer->Next_Material;
  1211.  
  1212.     while (Mats != NULL)
  1213.     {
  1214.       Temp = Mats->Next_Material;
  1215.       Mats->Next_Material = NULL;
  1216.       Destroy_Textures(Mats);
  1217.       Mats = Temp;
  1218.     }
  1219.  
  1220.     Destroy_TPat_Fields((TPATTERN *)Layer);
  1221.  
  1222.     switch (Layer->Type)
  1223.     {
  1224.       case PLAIN_PATTERN:
  1225.  
  1226.         Destroy_Pigment(Layer->Pigment);
  1227.         Destroy_Tnormal(Layer->Tnormal);
  1228.         Destroy_Finish(Layer->Finish);
  1229.         Destroy_Halo(Layer->Halo);
  1230.  
  1231.       break;
  1232.  
  1233.  
  1234.       case BITMAP_PATTERN:
  1235.  
  1236.         Destroy_Textures(Layer->Materials);
  1237.         /*taken care of by Destroy_TPat_Fields*/
  1238.         /*Destroy_Image(Layer->Vals.Image);*/
  1239.  
  1240.       break;
  1241.     }
  1242.  
  1243.     Temp = (TEXTURE *)Layer->Next;
  1244.     POV_FREE(Layer);
  1245.     Layer = Temp;
  1246.   }
  1247. }
  1248.  
  1249.  
  1250.  
  1251. /*****************************************************************************
  1252. *
  1253. * FUNCTION
  1254. *
  1255. * INPUT
  1256. *   
  1257. * OUTPUT
  1258. *   
  1259. * RETURNS
  1260. *   
  1261. * AUTHOR
  1262. *
  1263. *   POV-Ray Team
  1264. *   
  1265. * DESCRIPTION
  1266. *
  1267. * CHANGES
  1268. *
  1269. ******************************************************************************/
  1270.  
  1271. void Post_Textures(Textures)
  1272. TEXTURE *Textures;
  1273. {
  1274.   TEXTURE *Layer, *Material;
  1275.   int i;
  1276.   BLEND_MAP *Map;
  1277.   
  1278.   if (Textures == NULL)
  1279.   {
  1280.     return;
  1281.   }
  1282.  
  1283.   for (Layer = Textures; Layer != NULL; Layer = (TEXTURE *)Layer->Next)
  1284.   {
  1285.     if (!((Layer->Flags) & POST_DONE))
  1286.     {
  1287.       switch (Layer->Type)
  1288.       {
  1289.         case PLAIN_PATTERN:
  1290.  
  1291.           Post_Pigment(Layer->Pigment);
  1292.           Post_Tnormal(Layer->Tnormal);
  1293.           Post_Halo(Layer);
  1294.  
  1295.           break;
  1296.  
  1297.         case BITMAP_PATTERN:
  1298.  
  1299.           for (Material = Layer->Materials; Material != NULL; Material = Material->Next_Material)
  1300.  
  1301.             Post_Textures(Material);
  1302.  
  1303.             break;
  1304.       }
  1305.   
  1306.       if ((Map=Layer->Blend_Map) != NULL)
  1307.       {
  1308.         for (i = 0; i < Map->Number_Of_Entries; i++)
  1309.         {
  1310.            Post_Textures(Map->Blend_Map_Entries[i].Vals.Texture);
  1311.         }
  1312.       }
  1313.       else
  1314.       {
  1315.         if (Layer->Type == AVERAGE_PATTERN)
  1316.         {
  1317.            Error("No texture map in averaged texture.");
  1318.         }
  1319.       }
  1320.     }
  1321.   }
  1322. }
  1323.  
  1324.  
  1325.  
  1326. /*****************************************************************************
  1327. *
  1328. * FUNCTION
  1329. *
  1330. *   Test_Opacity
  1331. *
  1332. * INPUT
  1333. *
  1334. *   Object - Pointer to object
  1335. *
  1336. * OUTPUT
  1337. *
  1338. * RETURNS
  1339. *
  1340. *   int - TRUE, if opaque
  1341. *
  1342. * AUTHOR
  1343. *
  1344. *   Dieter Bayer
  1345. *   
  1346. * DESCRIPTION
  1347. *
  1348. *   Test wether an object is opaque or not, i.e. wether the texture contains
  1349. *   a non-zero filter or alpha channel.
  1350. *
  1351. * CHANGES
  1352. *
  1353. *   Aug 1994 : Creation.
  1354. *
  1355. *   Oct 1994 : Added code to check for opaque image maps. [DB]
  1356. *
  1357. *   Jun 1995 : Added code to check for alpha channel image maps. [DB]
  1358. *
  1359. ******************************************************************************/
  1360.  
  1361. int Test_Opacity(Texture)
  1362. TEXTURE *Texture;
  1363. {
  1364.   int x, y;
  1365.   int Opaque, Help;
  1366.   IMAGE *Image;
  1367.   TEXTURE *Layer, *Material;
  1368.  
  1369.   if (Texture == NULL)
  1370.   {
  1371.     return(FALSE);
  1372.   }
  1373.  
  1374.   /* We assume that the object is not opaque. */
  1375.  
  1376.   Opaque = FALSE;
  1377.  
  1378.   /* Test all layers. If at least one layer is opaque the object is opaque. */
  1379.  
  1380.   for (Layer = Texture; Layer != NULL; Layer = (TEXTURE *)Layer->Next)
  1381.   {
  1382.     switch (Layer->Type)
  1383.     {
  1384.       case PLAIN_PATTERN:
  1385.  
  1386.         /* Test image map for opacity. */
  1387.  
  1388.         if ((Layer->Pigment->Type == BITMAP_PATTERN) &&
  1389.             (Layer->Pigment->Vals.Image != NULL))
  1390.         {
  1391.           /* Layer is not opaque if the image map is used just once. */
  1392.  
  1393.           if (Layer->Pigment->Vals.Image->Once_Flag)
  1394.           {
  1395.             break;
  1396.           }
  1397.  
  1398.           /* Layer is not opaque if there's at least one non-opaque color. */
  1399.  
  1400.           Image = Layer->Pigment->Vals.Image;
  1401.  
  1402.           Help = FALSE;
  1403.  
  1404.           if (Image->Colour_Map != NULL)
  1405.           {
  1406.             /* Test color map. */
  1407.  
  1408.             for (x = 0; x < (int)Image->Colour_Map_Size; x++)
  1409.             {
  1410.               if (fabs(Image->Colour_Map[x].Filter) > EPSILON)
  1411.               {
  1412.                 Help = TRUE;
  1413.  
  1414.                 break;
  1415.               }
  1416.             }
  1417.           }
  1418.           else
  1419.           {
  1420.             /* Test image. */
  1421.  
  1422.             if (Image->data.rgb_lines[0].transm != NULL)
  1423.             {
  1424.               for (y = 0; y < Image->iheight; y++)
  1425.               {
  1426.                 for (x = 0; x < Image->iwidth; x++)
  1427.                 {
  1428.                   if (fabs(Image->data.rgb_lines[y].transm[x]) > EPSILON)
  1429.                   {
  1430.                     Help = TRUE;
  1431.  
  1432.                     break;
  1433.                   }
  1434.                 }
  1435.  
  1436.                 if (Help)
  1437.                 {
  1438.                   break;
  1439.                 }
  1440.               }
  1441.             }
  1442.           }
  1443.  
  1444.           if (Help)
  1445.           {
  1446.             break;
  1447.           }
  1448.         }
  1449.  
  1450.         if (!(Layer->Pigment->Flags & HAS_FILTER))
  1451.         {
  1452.           Opaque = TRUE;
  1453.         }
  1454.  
  1455.         break;
  1456.  
  1457.       case BITMAP_PATTERN:
  1458.  
  1459.         /* Layer is not opaque if the image map is used just once. */
  1460.  
  1461.         if (Layer->Vals.Image != NULL)
  1462.         {
  1463.           if (Layer->Vals.Image->Once_Flag)
  1464.           {
  1465.             break;
  1466.           }
  1467.         }
  1468.  
  1469.         /* Layer is opaque if all materials are opaque. */
  1470.  
  1471.         Help = TRUE;
  1472.  
  1473.         for (Material = Layer->Materials; Material != NULL; Material = Material->Next_Material)
  1474.         {
  1475.           if (!Test_Opacity(Material))
  1476.           {
  1477.             /* Material is not opaque --> layer is not opaque. */
  1478.  
  1479.             Help = FALSE;
  1480.  
  1481.             break;
  1482.           }
  1483.         }
  1484.  
  1485.         if (Help)
  1486.         {
  1487.           Opaque = TRUE;
  1488.         }
  1489.  
  1490.         break;
  1491.     }
  1492.   }
  1493.  
  1494.   return(Opaque);
  1495. }
  1496.  
  1497.  
  1498.  
  1499. /*****************************************************************************
  1500. *
  1501. * FUNCTION
  1502. *
  1503. *   POV_Std_rand
  1504. *
  1505. * INPUT
  1506. *
  1507. * OUTPUT
  1508. *   
  1509. * RETURNS
  1510. *
  1511. *   int - random value
  1512. *   
  1513. * AUTHOR
  1514. *
  1515. *   POV-Ray Team
  1516. *   
  1517. * DESCRIPTION
  1518. *
  1519. *   Standard pseudo-random function.
  1520. *
  1521. * CHANGES
  1522. *
  1523. *   Feb 1995 : Creation.
  1524. *
  1525. ******************************************************************************/
  1526.  
  1527. int POV_Std_rand()
  1528. {
  1529.   next_rand = next_rand * 1812433253L + 12345L;
  1530.  
  1531.   return((int)(next_rand >> 16) & RNDMASK);
  1532. }
  1533.  
  1534.  
  1535.  
  1536. /*****************************************************************************
  1537. *
  1538. * FUNCTION
  1539. *
  1540. *   POV_Std_srand
  1541. *
  1542. * INPUT
  1543. *
  1544. *   seed - Pseudo-random generator start value
  1545. *   
  1546. * OUTPUT
  1547. *   
  1548. * RETURNS
  1549. *   
  1550. * AUTHOR
  1551. *
  1552. *   POV-Ray Team
  1553. *   
  1554. * DESCRIPTION
  1555. *
  1556. *   Set start value for pseudo-random generator.
  1557. *
  1558. * CHANGES
  1559. *
  1560. *   Feb 1995 : Creation.
  1561. *
  1562. ******************************************************************************/
  1563.  
  1564. void POV_Std_srand(seed)
  1565. int seed;
  1566. {
  1567.   next_rand = (unsigned long int)seed;
  1568. }
  1569.  
  1570.